/*
 * Copyright (C), 2002-2016, 苏宁易购电子商务有限公司
 * FileName: ModelBlendServiceImpl.java
 * Author:   13075787
 * Date:     2016年7月11日 下午1:58:10
 * Description: //模块目的、功能描述      
 * History: //修改记录
 * <author>      <time>      <version>    <desc>
 * 修改人姓名             修改时间            版本号                  描述
 */
package com.suning.sawp.service.impl.model;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.suning.sawp.constants.ConfigConstants;
import com.suning.sawp.constants.LoggerConstants;
import com.suning.sawp.dto.mainpush.StoreManDto;
import com.suning.sawp.intf.model.ModelConstant;
import com.suning.sawp.intf.model.ModelMainListBean;
import com.suning.sawp.intf.model.ModelManageService;
import com.suning.sawp.intf.model.ModelProblemListBean;
import com.suning.sawp.intf.model.ModelTaskAssignDetailsBean;
import com.suning.sawp.intf.model.ModelZoneInfo;
import com.suning.sawp.intf.model.PriceTagDetail;
import com.suning.sawp.service.util.SCMConfigUtil;

/**
 * 样机管理<br>
 * 公共方法
 *
 * @author 13075787
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service("modelBlendService")
public class ModelBlendServiceImpl {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoggerConstants.SAWP_SERVICE);

    private static final Integer TO_PROB_AUDIT_SIZE = 5000;

    @Autowired
    ModelBlendDaoServiceImpl modelBlendDaoService;

    @Autowired
    ModelTaskDaoServiceImpl modelTaskDaoService;

    @Autowired
    ModelCommClusterServiceImpl modelCommClusterService;

    @Autowired
    ModelManageService modelManageService;

    /**
     * 检查员工基本信息是否缺失
     */
    public boolean checkManInfo(StoreManDto storeMan) {
        boolean result = false;
        if (null != storeMan) {
            if (StringUtils.isNotBlank(storeMan.getStoreCode()) && StringUtils.isNotBlank(storeMan.getBranchCode())
                    && StringUtils.isNotBlank(storeMan.getPositionId())
                    && StringUtils.isNotBlank(storeMan.getRegionCode())) {
                result = true;
            } else {
                LOGGER.error("样机管理-该员工" + storeMan.getStaffId() + "信息缺失:" + storeMan.toString());
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 更新样机清单中的数据(删除)
     *
     * @param mainList
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public void updateOrDelModelCommNum(List<ModelMainListBean> mainList) {
        if (CollectionUtils.isNotEmpty(mainList)) {
            // 要更新的数据
            List<ModelMainListBean> updateList = new ArrayList<ModelMainListBean>();
            // 要删除的数据
            List<ModelMainListBean> delList = new ArrayList<ModelMainListBean>();
            for (ModelMainListBean modelMainListBean : mainList) {
                if (null != modelMainListBean && StringUtils.isNotBlank(modelMainListBean.getCommCode())
                        && StringUtils.isNotBlank(modelMainListBean.getStoreCode())) {
                    if (null != modelMainListBean.getCommNum()
                            && modelMainListBean.getCommNum().intValue() > ModelConstant.NUM_ZERO) {
                        // 更新数量的数据
                        modelMainListBean.setNewFlag(ModelConstant.MODEL_OLD);
                        updateList.add(modelMainListBean);
                    } else {
                        // 要删除的样机
                        delList.add(modelMainListBean);
                    }
                }
            }
            // 更新数量
            modelBlendDaoService.updateOrDelModelCommNum(updateList, false);
            // 删除
            modelBlendDaoService.updateOrDelModelCommNum(delList, true);
        }
    }

    /**
     * 功能描述: <br>
     * 检查该员工任务的有效性
     *
     * @param storeMan
     * @param taskId
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public boolean checkTaskStatus(StoreManDto storeMan, Long taskId) {
        boolean result = false;
        String checkFlag = SCMConfigUtil.getConfig(ConfigConstants.MODEL_TASK_CHECK_FLAG,
                String.valueOf(ModelConstant.TASK_VALID_STATUS_ENABLE));
        // 默认开启检查任务有效性的开关
        if (String.valueOf(ModelConstant.TASK_VALID_STATUS_ENABLE).equals(checkFlag)) {
            result = modelTaskDaoService.queryTaskExistFlag(storeMan.getStoreCode(), storeMan.getStaffId(), null,
                    taskId);
        } else {
            // 在关闭的情况下，则不判断任务是否有效
            result = true;
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 盘点提交
     */
    public void submitCheck() {
        // 1查询出任务结束/未盘点的任务(任务类型为盘点)
        boolean handleFlag = true;
        do {
            List<ModelTaskAssignDetailsBean> checkList = modelTaskDaoService
                    .queryTaskDetailCheck(ModelConstant.NUM_ZERO, null);
            if (CollectionUtils.isNotEmpty(checkList)) {
                // 待处理的数据
                List<ModelTaskAssignDetailsBean> upCheckList = new ArrayList<ModelTaskAssignDetailsBean>();
                Map<String, Object> paramMap = new HashMap<String, Object>();
                for (ModelTaskAssignDetailsBean modelTaskAssign : checkList) {
                    if (null != modelTaskAssign.getTaskId()
                            && StringUtils.isNotBlank(modelTaskAssign.getAcceptStaff())) {
                        String key = String.valueOf(modelTaskAssign.getTaskId()) + modelTaskAssign.getAcceptStaff();
                        if (null == paramMap.get(key)) {
                            paramMap.put(key, key);
                            // 将任务id和执行人筛选出来
                            upCheckList.add(modelTaskAssign);
                        }
                    }
                }
                // 2更新盘点表状态 + 3更新任务提交状态
                modelBlendDaoService.updateCheckStatusSumbit(upCheckList);
            } else {
                handleFlag = false;
            }

            // 强制终止设置
            if (this.getCloseFlag()) {
                handleFlag = false;
            }
        } while (handleFlag);
    }

    /**
     * 强制退出开关-退出盘点提交任务-默认关闭
     */
    private boolean getCloseFlag() {
        boolean result = false;
        // 不配置scm则为关闭状态
        String checkFlag = SCMConfigUtil.getConfig(ConfigConstants.MODEL_JOB_AUTO_CLOSE_FLAG,
                String.valueOf(ModelConstant.TASK_VALID_STATUS_DISABLE));
        // 默认开启检查任务有效性的开关
        if (String.valueOf(ModelConstant.TASK_VALID_STATUS_ENABLE).equals(checkFlag)) {
            result = true;
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 异常未处理数据自动提交，将状态修改为已处理
     */
    public void submitProbHandle() {
        boolean handleFlag = true;
        String handleEndTime = SCMConfigUtil.getConfig(ConfigConstants.MODEL_JOB_TO_AUDIT_PROB_SIZE,
                String.valueOf("1"));
        do {
            int count = modelBlendDaoService.updateProbIngToAudit(Integer.valueOf(handleEndTime), TO_PROB_AUDIT_SIZE,
                    "system");
            if (count <= ModelConstant.NUM_ZERO) {
                handleFlag = false;
            }

            // 强制终止设置
            if (this.getCloseFlag()) {
                handleFlag = false;
            }
        } while (handleFlag);
    }

    /**
     * 功能描述: <br>
     * 提交的盘点数据进行比较，产生异常数据
     */
    public void handleCheck() {
        boolean handleFlag = true;
        String maxSize = SCMConfigUtil.getConfig(ConfigConstants.MODEL_JOB_HANDLE_CHECK_SIZE, String.valueOf("500"));
        do {
            List<ModelProblemListBean> allList = new ArrayList<ModelProblemListBean>();
            /*
             * 0需要对比的任务列表查询出来,且该列表是后面需要后面更新任务提交状态的->2
             * 查询符合异常比对条件的任务列表，MODEL_TASK_ASSIGN_DETAILS任务明细，盘点任务提交状态为已提交
             */
            List<ModelProblemListBean> taskList = modelBlendDaoService.getModelDetailTaskList(ModelConstant.NUM_ZERO,
                    Integer.valueOf(maxSize));
            allList.addAll(taskList);
            /*
             * 1查询分配详情表中，查出盘点类型任务已经提交的任务数据; 2传入任务id、品牌编码、门店编码; 临时表 关联样机清单 关联盘点数据表
             */
            List<ModelProblemListBean> probList = modelBlendDaoService.getModelProblemList(ModelConstant.NUM_ZERO,
                    Integer.valueOf(maxSize));
            allList.addAll(probList);
            // 新样商品列表-无需处理 - 需要变更的样机清单数据
            List<ModelMainListBean> mainList = new ArrayList<ModelMainListBean>();
            // 非新样需要插入到问题列表
            List<ModelProblemListBean> noProbList = new ArrayList<ModelProblemListBean>();
            if (CollectionUtils.isNotEmpty(allList)) {
                // 2.5需要过滤出带有新样标识的数据，然后将该部分数据直接处理，其余数据做如下的处理
                for (ModelProblemListBean modelProblem : probList) {
                    if (null != modelProblem) {
                        // 首先判断是否为异常数据-数量相同
                        Integer actualCommNum = modelProblem.getActualCommNum();
                        Integer checkCommNum = modelProblem.getCheckCommNum();
                        if (ModelConstant.MODEL_NEW.equals(Integer.valueOf(modelProblem.getNewFlag()))) {
                            // 维护簇商品信息
                            if (StringUtils.isNotBlank(modelProblem.getActualCommCode())
                                    && StringUtils.isNotBlank(modelProblem.getCommCode())
                                    && !modelProblem.getCommCode().equals(modelProblem.getActualCommCode())) {
                                ModelZoneInfo modelZone = new ModelZoneInfo();
                                modelZone.setDisCode(modelProblem.getDisCode());
                                modelZone.setDisName(modelProblem.getDisName());
                                modelZone.setOrgCode(modelProblem.getOrgCode());
                                modelZone.setOrgName(modelProblem.getOrgName());
                                //DELETE by xj  不对簇进行操作
//                                modelCommClusterService.addModelCommCluster(modelZone, modelProblem.getActualCommCode(),
//                                        modelProblem.getCommCode());
                                // 插入真实出样商品->入库样机清单
                                this.addCommMain(modelProblem.getStoreCode(), modelProblem.getActualCommCode());
                            }
                            // 若是未盘点到的也产生异常数据
                            if (null == modelProblem.getCheckCommNum()) {
                                // 新样未盘点到也插入异常中
                                noProbList.add(modelProblem);
                            }
                            // 盘点数量，若未盘点到则数量用原样机清单数量
                            int commNum = null != modelProblem.getCheckCommNum()
                                    ? modelProblem.getCheckCommNum().intValue() : modelProblem.getActualCommNum();
                            // 要修改的样机清单数据
                            ModelMainListBean mainModel = new ModelMainListBean();
                            mainModel.setStoreCode(modelProblem.getStoreCode());
                            mainModel.setCommCode(modelProblem.getCommCode());
                            mainModel.setCommNum(commNum);
                            mainList.add(mainModel);
                        } else {
                            if (null != actualCommNum && null != checkCommNum && actualCommNum.equals(checkCommNum)) {
                                continue;
                            }
                            // 非新样机的插入异常中
                            noProbList.add(modelProblem);
                        }
                    }
                }
                // 直接更新样机清单的数据-更新（删除）样机清单中的数据
                this.updateOrDelModelCommNum(mainList);
                // 3将查询出的数据插入的异常处理表-批量插入
                modelBlendDaoService.upsertModelProblemList(noProbList);
                // 4将处理过的任务提交状态更新为 2完成对比-过滤
                if (CollectionUtils.isNotEmpty(allList)) {
                    List<ModelProblemListBean> handleProbList = new ArrayList<ModelProblemListBean>();
                    // 用于去重
                    Map<String, Object> probMap = new HashMap<String, Object>();
                    for (ModelProblemListBean modelProb : allList) {
                        String key = modelProb.getTaskId() + modelProb.getStoreCode() + modelProb.getBranch9code();
                        if (null == probMap.get(key)) {
                            probMap.put(key, key);
                            handleProbList.add(modelProb);
                        }
                    }
                    // 批量更新任务表
                    modelBlendDaoService.updateCheckTaskStatus(handleProbList);
                }
            } else {
                handleFlag = false;
            }

            // 强制终止设置
            if (this.getCloseFlag()) {
                handleFlag = false;
            }
        } while (handleFlag);
    }

    /*
     * 插入样机清单
     */
    public void addCommMain(String storeCode, String commCode) {
        if (StringUtils.isNotBlank(storeCode) && StringUtils.isNotBlank(commCode)) {
            try {
                // 2.查询样机清单 1.有 2无插入
                ModelMainListBean modelMain = modelBlendDaoService.queryModelCommInfo(storeCode, commCode);
                if (null == modelMain) {
                    // 不存在则插入
                    List<PriceTagDetail> commList = new ArrayList<PriceTagDetail>();
                    PriceTagDetail priceTagDetail = new PriceTagDetail();
                    priceTagDetail.setCmmdtyCode(commCode);
                    // 样机库
                    priceTagDetail.setCounterFlag("0");
                    // 先插入样机清单表
                    commList.add(priceTagDetail);
                    modelManageService.saveModelList(storeCode, commList);
                }
            } catch (Exception e) {
                LOGGER.error("样机管理-产生异常定时任务，真实出样商品入库异常:商品编码%s,门店编码:%s", commCode, storeCode, e);
            }
        }
    }

}
